package cn.kicsy.www.anonymous_bbs.service;

import cn.kicsy.www.anonymous_bbs.entity.Comment;
import cn.kicsy.www.anonymous_bbs.entity.Post;
import cn.kicsy.www.anonymous_bbs.repository.CommentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class CommentService {
    
    @Autowired
    private CommentRepository commentRepository;
    
    @Autowired
    private PostService postService;
    
    @Autowired
    private RandomNicknameService randomNicknameService;
    
    @Autowired
    private SensitiveWordFilterService sensitiveWordFilterService;
    
    @Autowired
    private BanService banService;
    
    @Autowired
    private NotificationService notificationService;
    
    @Autowired
    private IpLocationService ipLocationService;
    
    /**
     * 创建评论
     * @param postId 帖子ID
     * @param content 评论内容
     * @param ipAddress 用户IP地址
     * @return 创建的评论
     */
    public Comment createComment(Long postId, String content, String ipAddress) {
        // 检查用户是否被封禁
        if (banService.isBanned(ipAddress)) {
            throw new RuntimeException("您已被封禁，无法发表评论。原因：" + banService.getBanReason(ipAddress));
        }
        
        // 检查内容是否为空
        if (content == null || content.trim().isEmpty()) {
            throw new RuntimeException("评论内容不能为空");
        }
        
        // 检查内容长度是否合理
        if (content.length() > 5000) {
            throw new RuntimeException("评论内容不能超过5000字符");
        }
        
        // 检查帖子是否存在
        Post post = postService.getPostById(postId);
        if (post == null) {
            throw new RuntimeException("帖子不存在");
        }
        
        // 创建评论对象
        Comment comment = new Comment();
        comment.setAuthorName(randomNicknameService.generateRandomNickname());
        comment.setContent(content);
        comment.setIpAddress(ipAddress);
        comment.setPost(post);
        
        // 设置IP地理位置
        String location = ipLocationService.getLocation(ipAddress);
        comment.setLocation(location);
        
        // 检查并标记敏感词
        if (sensitiveWordFilterService.containsSensitiveWords(content)) {
            comment.setHasSensitiveWords(true);
            // 可以在这里触发通知，提醒管理员有敏感内容
        }
        
        // 保存评论
        Comment savedComment = commentRepository.save(comment);
        
        // 如果评论的不是自己的帖子，可以发送通知
        if (!ipAddress.equals(post.getIpAddress())) {
            notificationService.createNotification(
                post.getIpAddress(),
                "comment",
                "您的帖子收到了一条评论",
                postId,
                savedComment.getId()
            );
        }
        
        return savedComment;
    }
    
    /**
     * 回复评论
     * @param postId 帖子ID
     * @param parentCommentId 父评论ID
     * @param content 回复内容
     * @param ipAddress 用户IP地址
     * @return 创建的回复
     */
    public Comment replyToComment(Long postId, Long parentCommentId, String content, String ipAddress) {
        // 检查用户是否被封禁
        if (banService.isBanned(ipAddress)) {
            throw new RuntimeException("您已被封禁，无法回复评论。原因：" + banService.getBanReason(ipAddress));
        }
        
        // 检查内容是否为空
        if (content == null || content.trim().isEmpty()) {
            throw new RuntimeException("回复内容不能为空");
        }
        
        // 检查内容长度是否合理
        if (content.length() > 3000) {
            throw new RuntimeException("回复内容不能超过3000字符");
        }
        
        // 检查父评论是否存在
        Optional<Comment> optionalParentComment = commentRepository.findById(parentCommentId);
        if (optionalParentComment.isEmpty()) {
            throw new RuntimeException("父评论不存在");
        }
        
        Comment parentComment = optionalParentComment.get();
        
        // 检查父评论是否属于指定的帖子
        if (!parentComment.getPost().getId().equals(postId)) {
            throw new RuntimeException("评论不属于该帖子");
        }
        
        // 创建回复对象
        Comment reply = new Comment();
        reply.setAuthorName(randomNicknameService.generateRandomNickname());
        reply.setContent(content);
        reply.setIpAddress(ipAddress);
        reply.setPost(parentComment.getPost());
        reply.setParentComment(parentComment);
        
        // 设置IP地理位置
        String location = ipLocationService.getLocation(ipAddress);
        reply.setLocation(location);
        
        // 检查并标记敏感词
        if (sensitiveWordFilterService.containsSensitiveWords(content)) {
            reply.setHasSensitiveWords(true);
            // 可以在这里触发通知，提醒管理员有敏感内容
        }
        
        // 保存回复
        Comment savedReply = commentRepository.save(reply);
        
        // 如果回复的不是自己的评论，可以发送通知
        if (!ipAddress.equals(parentComment.getIpAddress())) {
            notificationService.createNotification(
                parentComment.getIpAddress(),
                "comment_reply",
                "您的评论收到了一条回复",
                postId,
                savedReply.getId()
            );
        }
        
        return savedReply;
    }
    
    /**
     * 获取帖子的根评论列表（不包含回复）
     * @param postId 帖子ID
     * @return 根评论列表
     */
    public List<Comment> getRootCommentsByPostId(Long postId) {
        return commentRepository.findByPostIdAndParentCommentIsNullOrderByCreatedAtAsc(postId);
    }
    
    /**
     * 获取评论的回复列表
     * @param commentId 评论ID
     * @return 回复列表
     */
    public List<Comment> getRepliesByCommentId(Long commentId) {
        return commentRepository.findByParentCommentIdOrderByCreatedAtAsc(commentId);
    }
    
    /**
     * 点赞评论
     * @param commentId 评论ID
     * @param ipAddress 用户IP地址
     * @return 点赞后的点赞数
     */
    public int likeComment(Long commentId, String ipAddress) {
        // 检查用户是否被封禁
        if (banService.isBanned(ipAddress)) {
            throw new RuntimeException("您已被封禁，无法点赞评论");
        }
        
        Optional<Comment> optionalComment = commentRepository.findById(commentId);
        if (optionalComment.isPresent()) {
            Comment comment = optionalComment.get();
            comment.setLikeCount(comment.getLikeCount() + 1);
            comment = commentRepository.save(comment);
            
            // 如果点赞的不是自己的评论，可以发送通知
            if (!ipAddress.equals(comment.getIpAddress())) {
                notificationService.createNotification(
                    comment.getIpAddress(),
                    "comment_liked",
                    "您的评论收到了一个点赞",
                    comment.getPost().getId(),
                    commentId
                );
            }
            
            return comment.getLikeCount();
        }
        throw new RuntimeException("评论不存在");
    }
}